// 用 import * as util from ('./*****.js')导入使用

/* 
    函数作用：把key=value&key=value 格式的字符串处理为对象
    函数的参数：
        s:字符串，你需要处理的字符
    函数的返回值：
        处理之后的这个对象
*/
export function strToObj(s) {
    var arr = s.split("&");
    var obj = {};
    arr.forEach(function (item) {
        var a = item.split("=");

        obj[a[0]] = a[1];
    });

    return obj;
}

/* 
    函数的作用：生成任意区间（范围）的随机正数
    函数的参数：
        n1:数字
        n2:数字
    函数的返回值：
        生成的能随机数
*/
export function randomNum(n1, n2) {
    var min = n1 < n2 ? n1 : n2;
    var max = n1 > n2 ? n1 : n2;

    var r = parseInt(Math.random() * (max - min + 1) + min);
    return r;
}

/* 
    函数的作用：格式化时间对象为我们想要的格式
    函数的参数：
        date:时间对象
        type:'-' | '/' | '.' | '年月日'
    函数的返回值：
        把格式化好的这个时间对象返回
*/
export function formatTime(date, type) {
    var y = date.getFullYear();
    var m = date.getMonth() + 1;
    var d = date.getDate();
    var h = date.getHours();
    var min = date.getMinutes();
    var sec = date.getSeconds();

    var w = date.getDay(); // 0-6
    var week = [
        "星期天",
        "星期一",
        "星期二",
        "星期三",
        "星期四",
        "星期五",
        "星期六",
    ];

    // 判断type是否有值，如果有，说明需要按照指定的格式去拼接
    if (type == undefined) {
        return `${y}年${m}月${d}日 ${h}:${min}:${sec}  ${week[w]}`;
    }
    return `${y}${type}${m}${type}${d} ${h}:${min}:${sec}  ${week[w]}`;
}

/* 
    函数的作用：计算两个时间的时间差
    参数：
        date1:时间对象
        date2:时间对象
    函数的返回值：
        返回一个对象，对象存储就是两个时间差的 天数 小时数 分钟数 和 秒数
*/
export function shijiancha(date1, date2) {
    var t1 = date1.getTime();
    var t2 = date2.getTime();
    var t = Math.abs(t1 - t2);
    var d = parseInt(t / 1000 / 60 / 60 / 24);
    var s = parseInt(t / 1000 / 60 / 60) % 24;
    var f = parseInt(t / 1000 / 60) % 60;
    var m = parseInt(t / 1000) % 60;
    var obj = {
        day: d,
        hours: s,
        minutes: f,
        seconds: m,
    };
    return obj;
}

/* 
    函数的作用：获得该元素以外的所有兄弟节点
    函数的参数：该元素
    函数的返回值：兄弟节点集合的数组
*/
export function getSibilings(ele) {
    var arr = [];
    var pre = ele.previousElementSibling;
    if (pre != null) {
        arr.push(pre);
        while (pre.previousElementSibling) {
            pre = pre.previousElementSibling;
            arr.push(pre);
        }
        arr.reverse();
    }

    var next = ele.nextElementSibling;
    if (next != null) {
        arr.push(next);
        while (next.nextElementSibling) {
            next = next.nextElementSibling;
            arr.push(next);
        }
    }

    return arr;
}


/* 
    函数的作用：封装一个函数，用于获取指定的元素的所有父级元素
    getParentNodes(box)
*/
export function getParentNodes(ele) {
    var arr = [];
    var pre = ele.parentNode;
    if (pre != null) {
        arr.push(pre);
        while (pre.parentNode) {
            pre = pre.parentNode;
            arr.push(pre);
        }
        arr.reverse();
    }
    return arr;
}
/* 
       ## 3.封装一个函数，计算任意一个时间对象是当前时间多久之前
       返回值：
             -   如果天数大于7则显示这个时间对象的年月日
             -   如果天数小于7并且天数不为0 ，显示天数
             -   如果天数为0 ，但是小时数不为0 ，就显示小时数
             -   如果天数为0 ，小时数也为0，但是分钟数不为0 ，就实现分钟数
             -   如果天数为0，小时数为0，分钟数为，就实现0秒数
        参数：时间对象
       
       */
export function time(d) {
    var currentDate = new Date();
    var t = Math.abs(d.getTime() - currentDate.getTime());
    var tian = parseInt(t / 1000 / 60 / 60 / 24);
    var xiaoshi = parseInt(t / 1000 / 60 / 60) % 24;
    var fenzhong = parseInt(t / 1000 / 60) % 60;
    var miaoshu = parseInt(t / 1000) % 60;

    if (tian > 7) {
        var nian = d.getFullYear();
        var yue = d.getMonth() + 1;
        var riqi = d.getDate();
        return `${nian}年${yue}月${riqi}日`;
    }

    if (tian <= 7 && tian != 0) {
        return `${tian}天前`;
    }

    if (xiaoshi != 0) {
        return `${xiaoshi}小时之前`;
    }

    if (fenzhong != 0) {
        return `${fenzhong}分钟之前`;
    }

    return `${miaoshu}秒之前`;
}

// 函数作用：给某个元素设置样式
// 参数1 元素的class类名 参数2一个对象，里面的设置的样式

export function setStyle(ele, obj) {
    // console.log(ele,obj);
    let e = document.querySelector(ele)
    let p = e.parentNode
    let E = e.cloneNode(true)
    e.remove()
    p.appendChild(E)
    console.log(E, E.className, E.tagName.toLowerCase());
    let yuansu = document.createElement(e.tagName.toLowerCase())

    yuansu.classList.add(e.className)

    console.log(yuansu);
    for (key in obj) {
        let k = key
        let v = obj[key]
        yuansu.style.border = '1px'
    }
}
// 函数的调用
// setStyle('.container', {
//     width: '100px',
//     height: '100px',
// })





//对移除类名代码进行封装
//   参数1：一个数组 参数2：移除的类名
//结果就是移除arr里面的某个类名
let remove = (arr, str) => {
    arr.forEach((item) => {
        item.classList.remove(str);
    });
};

// 元素进行动画
export function move(ele, options, callback) {

    let len = 0;
    for (let attr in options) {
        len++;
        let target = options[attr];
        let fun = () => {
            let current = parseInt(window.getComputedStyle(ele)[attr]);
            let speed = (target - current) / 20;
            speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
            current += speed;
            ele.style[attr] = current + "px";
            ele[attr] = requestAnimationFrame(fun);

            if (speed == 0) {
                cancelAnimationFrame(ele[attr]);
                len--;
                if (len == 0) {
                    callback ? callback() : "";
                }
            }
        };
        cancelAnimationFrame(ele[attr]);
        ele[attr] = requestAnimationFrame(fun);
    }
}
/* 
    封装操作cookie的方法
        获取 或者 设置
*/

/* 
    函数的作用：设置cookie
    函数是否有参数：有
        key 必填参数
        value 必填参数
        date 选填 单位 分钟
    函数是否有返回值：
        不需要返回值 因为只做设置的操作
*/

export function setCookie(key, value, date) {
    // 对必填参数做一个判断的操作
    // 没有传递参数的时候 key = undefined
    // 判断错误的情况
    if (key == undefined || value == undefined) {
        //手动抛出异常（错误）
        // 当执行这句代码的时候 抛出错误的同时 还是终止代码执行
        throw Error('key和value是必填参数')
    }

    //  如果有date参数 设置过期时间
    //  如果没有date参数，就使用默认的过期时间（不设置过期时间）
    if (date) {
        //过期时间的值一定要为一个时间对象
        // 传递过来的date为一个数字 需要把这个数字变成对应的时间对象
        // date = 30 表示30分钟之后过期， 当前时间 后的30分钟过期
        // 先得到当前时间对象 利用这个当前时间对象得到30分钟之后 的时间对象
        // cookie的过期时间 是按照零时区 的时间对象来计算
        //  浏览器是按照当前时区来展示， +8时区的时间 比0时区时间多8个钟
        // 12:00 设置为过期时间，会等到0时区的12:00才会过期
        // 设置cookie过期时间的时候 应都要在当前的时间基础上-8个钟 + 传递的分钟数
        let d = new Date();
        let time = d.getTime() - 8 * 60 * 60 * 1000 + date * 60 * 1000;

        // 怎么根据时间戳设置时间对象
        // date.setTime()  根据时间戳来设置时间对象
        d.setTime(time)

        document.cookie = `${key}=${value};expires=${d};`;
        return
    }

    document.cookie = `${key}=${value};`;
}

/* 
    函数的作用：获取cookie
    函数是否有参数：可有可无
        key:可选项
            有：那么就是获取该key对应的value
            没有：获取所有的cookie ，以对象的形式返回
    函数是否有返回值：有
        根据参数决定
        有参数就返回指定的cookie
        没有参数 返回对象
*/

export function getCookie(key) {
    var cookie = document.cookie;
    // name=张三; age=18  字符串
    // {name:'张三',age:18} 
    //  以 '; ' 来进行分割
    var arr = cookie.split('; ')
    var obj = {};
    arr.forEach(item => {
        // item  为 name=张三
        // 以= 进行分割
        let val = item.split('=')
        obj[val[0]] = val[1];
    })


    if (key) {
        return obj[key];
    }
    return obj;
}
// 移除cookie
function delCookie(key) {
    setCookie(key, '123', -10)
}



/* 
      封装一个函数，用于获取指定类名的元素，
     //  先判断本身这个元素是否拥有这个类名，有则把这个元素直接返回
 // 如果没有获取父元素来判断，如果其中一个父元素有该类名，则返回该父元素
    */
 export function getTarget(ele, className) {
    if (ele.classList.contains(className)) {
        return ele;
    }
    return getTarget(ele.parentNode, className)
}
// 使用
// let ele = getTarget(target, 'goodsItem');

/* 
      封装一个函数，用于获取指定类名的元素，
     //  先判断本身这个元素是否拥有这个类名，有则把这个元素直接返回
 // 如果没有获取父元素来判断，如果其中一个父元素有该类名，则返回该父元素
    */
 export function getTarget2(ele, className) {
    if (ele.getAttribute(className)) {
        return ele;
    }
    return getTarget2(ele.parentNode, className)
}




// ajax封装
export function getAjax(httpUrl, data = {}, callbackFn = () => {}) {
    var xhr = new XMLHttpRequest();
    xhr.open("GET", httpUrl + parseDate(data));
    xhr.send();
    xhr.onload = () => {
        console.log(xhr.responseText);
        callbackFn(xhr)
    }
    //遍历这个对象的所有属性
    function parseDate(data) {
        var str = "?";
        for (var key in data) {
            str = str + key + "=" + data[key] + "&";
        }
        str = str.substr(0, str.length - 1);
        return str;
    }
}